<?php
namespace Tbf\Util;
/**
 * @deprecated
 */
class ArrayUtil
{
    /**
     * 扁平化数组
     * 生成只有1维的数组,去掉所有数组的key
     */
    public static function flat($array)
    {
        $tmp = array();
        foreach ($array as $v1) {
            if (is_array ( $v1 )) {
                $tmp = array_merge ( $tmp, self::flat ( $v1 ) );
            } else {
                $tmp [] = $v1;
            }
        }

        return $tmp;
    }
    /**
     * 数组是否仅仅是“数组”
     * 全部下标均为数字或只含数字的字符串
     * 相对与可以MAP数组而言
     @param array $array
     @return boolean
     */
    public static function isPlant($array)
    {
        foreach ($array as $k1=>$v1) {
            if (!(is_int($k1)||(ctype_digit($k1)))) {
                return false;
            }
        }

        return true;
    }
    /**
     * 返回数组的"数组"部分（数字下标）
     * 将下标重新排序
     */
    public static function plantPart($array)
    {
        $output = array();
        foreach ($array as $k1=>$v1) {
            if ( (is_int($k1)||(ctype_digit($k1))) ) {
                $output[] = $v1;
            }
        }

        return $output;
    }
    /**
     * 数组无顺序比较（递归）
     * 考虑key-value的key
     @param array $arr1
     @param array $arr2
     */
    public static function equalNoOrder($arr1,$arr2)
    {
        self::multisortRecursive($arr1);
        self::multisortRecursive($arr2);

        return $arr1==$arr2;
    }
    public static function multisortRecursive(&$arr,$deep=10)
    {
        if ($deep<0) {
            return tPanic('too deep recuresive');
        }
        foreach ($arr as &$v1) {
            if (is_array($v1)) {
                self::multisortRecursive($v1,$deep-1);
            }
        }
        array_multisort($arr);
    }
    /**
     * 简单数组是否不计顺序相等
     @param array $array1
     @param array $array2
     */
    public static function plantEquals($array1,$array2)
    {
        if (!self::isPlant($array1)) {
            return false;
        }
        if (!self::isPlant($array2)) {
            return false;
        }
        sort($array1);
        sort($array2);

        return $array1==$array2;
    }

    private static $_repeatRecursiveHave = array();
    /**
     * 去掉数组中的循环引用问题
     只去掉重复的数组和对象，不去掉其他重复元素
     使用传入引用自修改，不返回值。
     @param array $array
    */
    public static function removeRepeatRecursive(&$array)
    {
        if (!is_array($array)) {
            return tPanic('not an array');
        }
        self::$_repeatRecursiveHave = array();
        self::_removeRepeatRecursive($array);
        self::$_repeatRecursiveHave = array();

        return $array;
    }
    /**
     * 限制数组只包含某些key，去掉其他所有key
     * 备注：不关心原数组是否缺少某些key
     * @param data array 原始数组
     * @param key array 需要的key数组 ''表示不处理
     * @return array 返回数组
     */
    public static function onlyHave(&$data,$key=null)
    {
        if ($key===null) {
            return ;
        }
        if (is_string($key)) {
            $args = func_get_args();
            array_shift($args);

            return self::onlyHave($data,$args);
        }

        return $data = array_intersect_key($data,
                array_fill_keys($key, ''));
    }
    /**
     * 将数组中缺少的键赋值为null，
     * 并限制数组只包含某些key，
     @param array $data
     @param array $key
     */
    public static function completeKeys(&$data,$key=null)
    {
        if ($key===null) {
            return;
        }
        $key = array_fill_keys($key, null);
        $data = array_intersect_key($data, $key);
        $data = array_merge($key,$data);

        return $data;
    }
    /**
     * 数组递归合并
     * map数组合并
     * 普通数组覆盖
     * 注意：输入是普通数组，也会覆盖
     */
    public static function mergeR($a,$b)
    {
        $output = array();
        //特殊情况：b为空
        if (empty($b)) {
            return $a;
        }
        //特殊情况：普通数组
        if (self::isPlant($b)) {
            return $b;
        }
        //遍历a
        foreach ($a as $k1=>$v1) {
            //数组部分，追加
            if (is_int($k1)||(ctype_digit($k1))) {
                $output[] = $v1;
                continue;
            }
            //b也有这个，覆盖。
            if (isset($b[$k1])) {
                if (is_array($v1)&&is_array($b[$k1]) ) {
                    $output[$k1] = self::mergeR($v1,$b[$k1]);
                    continue;
                } else {
                    $output[$k1] = $b[$k1];
                }
                continue;
            }
            //b没有这个，也写上。
            $output[$k1] = $v1;
        }
        //遍历b
        foreach ($b as $k1=>$v1) {
            //数组部分，追加
            if (is_int($k1)||(ctype_digit($k1))) {
                $output[] = $v1;
                continue;
            }
            //a没有这个，写上。
            if (!isset($a[$k1])) {
                $output[$k1] = $v1;
            }
            //其他情况，遍历a时已经处理了。
        }

        return $output;
    }
    /**
     * 取出数组第一个元素（降维）
     * 与array_shift的优势在不改变原数据
      @param array $data
      @return mixed
     */
    public static function firstValue(array $data)
    {
        return array_shift($data);
    }
    /**
     * 使用某字段重新写数据的key
      @param array $data
      @param string $keyName
     */
    public static function reKeyById(array $data,$keyName='id')
    {
        $output = array();
        foreach ($data as $v1) {
            $output[$v1[$keyName]] = $v1;
        }

        return $output;
    }
    private static function _removeRepeatRecursive(&$array,$deep = 10)
    {
        if ($deep<=0) {
            return tPanic('recursive too deep');
        }
        self::$_repeatRecursiveHave[] = $array;
        foreach ($array as &$v1) {
            if (is_array($v1)||(is_object($v1))) {
                if (in_array($v1,self::$_repeatRecursiveHave,true)) {
                    unset($v1);
                    continue;
                }
                self::$_repeatRecursiveHave[] = $v1;
                self::_removeRepeatRecursive($v1);
            }
        }
    }
    /**
     * 检测数组是否所有值都为null
     * 空数组也返回true
     * */
    public static function isAllNull($data)
    {
        foreach ($data as $v1) {
            if ($v1!==null) {
                return false;
            }
        }

        return true;
    }
    /**
     * 检测数组是否所有值都为空
     * 空数组也返回true
     * */
    public static function isAllEmpty($data)
    {
        foreach ($data as $v1) {
            if (!empty($v1)) {
                return false;
            }
        }

        return true;
    }

    /**
     * 去掉所有值为null的元素
     * */
    public static function removeNull($data)
    {
        foreach ($data as $k1=>$v1) {
            if ($v1===null) {
                unset($data[$k1]);
            }
        }

        return $data;
    }
    /**
     * 列子矩阵
     * 1.所有行必须完全匹配
     * 2.每一行可以用不同的列包含.
     * 元素匹配使用===
     * */
    public static function checkColumnSubMatrix($origin,$sub)
    {
        foreach ($origin as $k1=>$row) {
            if (empty($sub[$k1])) {
                return false;
            }
            foreach ($sub[$k1] as $k2=>$v2) {
                if (is_null($v2)) {
                    if (is_null($origin[$k1][$k2])) {
                        continue;
                    } else {
                        return false;
                    }
                }
                if (!isset($origin[$k1][$k2])) {
                    return false;
                }
                if ($origin[$k1][$k2]!==$sub[$k1][$k2]) {
                    return false;
                }
            }
        }

        return true;
    }
    /**
     * 把数组里面的所有键名都换成小写
     * array_change_key_case
     * */
    public static function keyToLower($data,$recursion=false)
    {
        $output = array();
        foreach ($data as $key=>$value) {
            $key = strtolower($key);
            $output[$key] = $value;
        }

        return $output;
    }
    /**
     * 数组key变换
     * 将数组data里面的key,用table进行变换,
     * 1.data多余的key会被删除!
     * 2.table多余的key也不会存在!
     * 3.key不存在和值为null是一回事..使用isset
     * @param data array
     * @param table array
     * */
    public static function keyTran($data,$table)
    {
        $output = array();
        foreach ($table as $origin=>$new) {
            if (!isset($data[$origin])) {
                continue;
            }
            $output[$new] = $data[$origin];
        }

        return $output;
    }
    /**
    * 翻译数组
    * 将数组$data里面所有的字符串,都同$table进行变化
1.如果某个字符串不存在,则保持原样
2.递归里面所有的数组
    */
    public static function stringTran($data,$table)
    {
        $output = array();
        foreach ($data as $key=>$value) {
            if (isset($table[$key])) {
                $key = $table[$key];
            }
            if (is_string($value)&&isset($table[$value])) {
                $value = $table[$value];
            }
            if (is_array($value)) {
                $value = self::stringTran($value,$table);
            }
            $output[$key] = $value;
        }

        return $output;
    }
    /**
     * 把值是null的元素修改为空字符串''
     * */
    public static function NullValueToEmptyString($data)
    {
        foreach ($data as $key=>$value) {
            if (is_null($value)) {
                $data[$key] = '';
            }
        }

        return $data;
    }
    public static function checkSubArray($origin,$sub)
    {
        foreach ($sub as $key=>$value) {
            if (is_null($value)&&
                is_null($origin[$key])
                ){
                continue;
            }
            if (!isset($origin[$key])) {
                return false;
            }
            if ($origin[$key]!==$value) {
                return false;
            }
        }

        return true;
    }
}//class
